package com.qy.util;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Tuple;


/**
 * redis连接池管理类
 * @author liym
 *
 */
public class RedisPoolMgr {

	private static JedisPool pools;
	public static final int DEFAULT_EXPIRE=60*60*24*1;//默认缓存过期时间
	
	private static String address = "112.124.25.132";
//	private static String address = "localhost";
	private static String password = "mmnews";
	private static int database = 3;
	private static int port = 6379;
	
	/**
	 * 获取连接池
	 * @return
	 */
	private static JedisPool getPool(){
		if(pools==null){
			init();
		}
		return pools;
	}
	/**
	 * redis缓存连接池初始化
	 * @return
	 */
	public static boolean init() {
		
		// 建立连接池配置参数
		JedisPoolConfig config = new JedisPoolConfig();
		// 设置最大连接数
		config.setMaxTotal(500);
		// 设置最大阻塞时间，记住是毫秒数milliseconds
		config.setMaxWaitMillis(10000);
		// 设置最大空闲连接数
		config.setMaxIdle(10);
		// 在获取连接的时候检查有效性
		config.setTestOnBorrow(true);

		// 创建连接池
//		pools = new JedisPool(config,address, port);
		pools = new JedisPool(config, address, port, 100000, password, database);
		return true;
	}

	public static void close() {
		if (getPool() != null) {
			getPool().destroy();
			getPool().close();
		}
	}

	/**
	 * 存对象（单key）
	 */
	public static void set(String key, Object value) {
		Jedis jedis = getPool().getResource();
		try {
			jedis.set(key, JSONUtil.objToStr(value));
			jedis.expire(key, DEFAULT_EXPIRE);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 存对象（单key）
	 * @param key
	 * @param value
	 * @param expire
	 */
	public static void set(String key, Object value,int expire) {
		Jedis jedis = getPool().getResource();
		try {
			jedis.set(key, JSONUtil.objToStr(value));
			jedis.expire(key, expire);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 取对象（单key）
	 */
	public static Object get(String key, Class<?> clazz) {
		Jedis jedis = getPool().getResource();
		try {
			return JSONUtil.strToObj(jedis.get(key), clazz);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 存对象列表（单key）
	 */
	public static void setList(String key, List<?> list) {
		Jedis jedis = getPool().getResource();
		try {
			Pipeline pipeline = jedis.pipelined();
			for (int i = 0; i < list.size(); i++) {
				pipeline.lset(key, i, JSONUtil.objToStr(list.get(i)));
			}
			pipeline.sync();
		} finally {
			jedis.close();
		}
	}

	/**
	 * 取对象列表（单key）
	 */
	public static List<?> getList(String key, Class<?> clazz) {
		List<Object> objList = new ArrayList<Object>();

		Jedis jedis = getPool().getResource();
		try {
			List<String> strList = jedis.lrange(key, 0, -1);
			if (strList != null && strList.size() > 0) {
				for (int i = 0; i < strList.size(); i++) {
					objList.add(JSONUtil.strToObj(strList.get(i), clazz));
				}
			}
		} finally {
			jedis.close();
		}

		return objList;
	}


	
	/************************************************************************************/
	/**
	 * hashMap存值方式
	 * @param parentKey
	 * @param fieldKey
	 * @param obj
	 */
	public static void hashSet(String parentKey, String fieldKey, Object obj) {
		 Jedis jedis=getPool().getResource();
		try{
			jedis.hset(parentKey, fieldKey,JSONParser.getString(obj));
			jedis.expire(parentKey, DEFAULT_EXPIRE);
		}finally{
			jedis.close();
		}
		
	}
	
	/**
	 * 存放map的key值，带时效参数的
	 * @param parentKey
	 * @param fieldKey
	 * @param obj
	 * @param expire 有效时间秒
	 */
	public static void hashSet(String parentKey, String fieldKey, Object obj,int expire) {
		 Jedis jedis=getPool().getResource();
		try{
			jedis.hset(parentKey, fieldKey,JSONParser.getString(obj));
			if(expire>0){
				jedis.expire(parentKey, expire);
			}
			
		}finally{
			jedis.close();
		}
		
	}
	/**
	 * 删除一个map值
	 * @param parentKey
	 * @param fieldKey
	 */
	public static void hashDel(String parentKey, String fieldKey){
		 Jedis jedis=getPool().getResource();
		try{
			jedis.hdel(parentKey, fieldKey);
		}finally{
			jedis.close();
		}
	}
	
	/**
	 * 删除整个map
	 * @param parentKey
	 */
	public static void hashDel(String parentKey){
		 Jedis jedis=getPool().getResource();
		 try {
			 if(jedis.exists(parentKey)){
					jedis.hdel(parentKey);
				}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedis.close();
		}
		
		
	}
	/**
	 * hashMap取值方式
	 * @param parentKey
	 * @param fieldKey
	 * @return
	 */
	public static Object hashGet(String parentKey, String fieldKey) {
		Jedis jedis=getPool().getResource();
		try{
			return JSONParser.getObject(jedis.hget(parentKey, fieldKey));
		}finally{
			jedis.close();
		}
	}
	
	/**
	 * 获取map值
	 * @param fieldKey
	 * @param T
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> Map<String, T> hashGetAll(String fieldKey, Class<?> T) {
		Jedis jedis=getPool().getResource();
		try{
			Map<String, String> map = jedis.hgetAll(fieldKey);
			if(map == null || map.size() == 0){
				return null;
			}
			
			Map<String, T> result = new HashMap<String, T>();
			for(String key : map.keySet()){
				result.put(key, (T)JSONParser.getObject(map.get(key)));
			}
			return result;
		}finally{
			jedis.close();
		}
	}
	/**
	 * 添加排行榜
	 * @param key
	 * @param member
	 * @param score
	 */
	public static void addRank(String key, String member, long score) {
		Jedis jedis=getPool().getResource();
		try {
			deletePlayerRank(key, member);
			jedis.zadd(key, score, member);
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 获取当前页的排行玩家
	 * @param page
	 * @param pageSize
	 * @return
	 */
	public static Set<Tuple> getRankByPage(String key, int start, int end) {
		Jedis jedis = getPool().getResource();
		try {
			return jedis.zrevrangeWithScores(key, start, end);
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 获取在排行榜中的位置
	 */
	public static int getRankValue(String key, String member) {
		Jedis jedis = getPool().getResource();
		try {
			Long temp = jedis. zrevrank(key, member);
			if(null != temp) {
				return temp.intValue()+1;
			}
			return 0;
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 删除玩家在某个排行榜
	 * @param key
	 * @param member
	 */
	public static void deletePlayerRank(String key, String member) {
		Jedis jedis = getPool().getResource();
		try {
			jedis.zrem(key, member);
		} finally {
			jedis.close();
		}
	}
	
	/**
	 * 计算排行榜中的总记录数
	 * @param key
	 * @return
	 */
	public static long getRankTotalCount(String key) {
		Jedis jedis = getPool().getResource();
		try {
			return jedis.zcount(key, 0, Double.MAX_VALUE);
		} finally {
			jedis.close();
		}
	}

	/**
	 * 清除排行榜
	 * @param key
	 */
	public static void clearRank(String key){
		Jedis jedis = getPool().getResource();
		try {
			jedis.del(key);
		} finally {
			jedis.close();
		}
	}
	
	public static void main(String[] args) {
		RedisPoolMgr.init();
		
		RedisPoolMgr.set("test", 11234);
	}
	
}
